import pytest
from matplotlib._mathtext import Parser


# function to test (minimal stub for Parser.dfrac, see above for full context)
class DummyNum:
    def __init__(self, value):
        self.value = value
        self.width = len(str(value))
        self.height = 1
        self.depth = 0

    def shrink(self):
        pass


class DummyDen(DummyNum):
    pass


class DummyFontset:
    def get_underline_thickness(self, font, fontsize, dpi):
        return 0.5

    def get_metrics(self, font, font_class, sym, fontsize, dpi):
        class Metrics:
            ymax = 1
            ymin = -1

        class Info:
            metrics = Metrics()

        return Info()


class DummyParserState:
    def __init__(self):
        self.fontset = DummyFontset()
        self.font = "rm"
        self.fontsize = 12
        self.dpi = 100
        self.font_class = "rm"

    def get_current_underline_thickness(self):
        return self.fontset.get_underline_thickness(self.font, self.fontsize, self.dpi)


class DummyMathStyle:
    DISPLAYSTYLE = 0


class DummyParser:
    _MathStyle = DummyMathStyle

    def __init__(self):
        self._state_stack = [DummyParserState()]

    def get_state(self):
        return self._state_stack[-1]

    def _genfrac(self, ldelim, rdelim, rule, style, num, den):
        # For testing, just return a tuple of the arguments
        return (ldelim, rdelim, rule, style, num.value, den.value)

    def dfrac(self, toks):
        return self._genfrac(
            "",
            "",
            self.get_state().get_current_underline_thickness(),
            self._MathStyle.DISPLAYSTYLE,
            toks["num"],
            toks["den"],
        )


Parser = DummyParser  # For test code, use dummy


# Fixtures and helpers
@pytest.fixture
def parser():
    return Parser()


@pytest.fixture
def num():
    return DummyNum(1)


@pytest.fixture
def den():
    return DummyDen(2)


# 1. Basic Test Cases
def test_basic_integer_fraction(parser):
    # Basic: numerator and denominator are integers
    toks = {"num": DummyNum(3), "den": DummyDen(4)}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 3.43μs -> 3.49μs (1.81% slower)


def test_basic_string_fraction(parser):
    # Basic: numerator and denominator are strings
    toks = {"num": DummyNum("x"), "den": DummyDen("y")}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.35μs -> 2.29μs (3.02% faster)


def test_basic_float_fraction(parser):
    # Basic: numerator and denominator are floats
    toks = {"num": DummyNum(1.5), "den": DummyDen(2.5)}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.39μs -> 2.34μs (1.96% faster)


def test_basic_zero_numerator(parser):
    # Basic: numerator is zero
    toks = {"num": DummyNum(0), "den": DummyDen(5)}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.27μs -> 2.42μs (6.16% slower)


def test_basic_zero_denominator(parser):
    # Basic: denominator is zero (should still return, no division here)
    toks = {"num": DummyNum(5), "den": DummyDen(0)}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.34μs -> 2.26μs (3.32% faster)


# 2. Edge Test Cases


def test_empty_numerator(parser):
    # Edge: numerator is empty string
    toks = {"num": DummyNum(""), "den": DummyDen("nonempty")}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.20μs -> 2.33μs (5.41% slower)


def test_empty_denominator(parser):
    # Edge: denominator is empty string
    toks = {"num": DummyNum("nonempty"), "den": DummyDen("")}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.32μs -> 2.31μs (0.216% faster)


def test_both_empty(parser):
    # Edge: both numerator and denominator are empty
    toks = {"num": DummyNum(""), "den": DummyDen("")}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.32μs -> 2.18μs (6.76% faster)


def test_large_integer_numerator(parser):
    # Edge: very large numerator
    large_num = 10**100
    toks = {"num": DummyNum(large_num), "den": DummyDen(1)}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.30μs -> 2.28μs (0.967% faster)


def test_large_integer_denominator(parser):
    # Edge: very large denominator
    large_den = 10**100
    toks = {"num": DummyNum(1), "den": DummyDen(large_den)}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.34μs -> 2.25μs (3.86% faster)


def test_special_characters(parser):
    # Edge: numerator and denominator with special characters
    toks = {"num": DummyNum(r"\alpha_1"), "den": DummyDen(r"\beta^2")}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.33μs -> 2.33μs (0.343% slower)


def test_unicode_characters(parser):
    # Edge: numerator and denominator with unicode
    toks = {"num": DummyNum("π"), "den": DummyDen("θ")}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.28μs -> 2.40μs (4.88% slower)


def test_none_numerator(parser):
    # Edge: numerator is None
    toks = {"num": DummyNum(None), "den": DummyDen("den")}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.21μs -> 2.17μs (1.94% faster)


def test_none_denominator(parser):
    # Edge: denominator is None
    toks = {"num": DummyNum("num"), "den": DummyDen(None)}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.32μs -> 2.18μs (6.42% faster)


def test_numerator_object(parser):
    # Edge: numerator is a custom object
    class X:
        def __str__(self):
            return "X"

    toks = {"num": DummyNum(X()), "den": DummyDen("den")}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.35μs -> 2.27μs (3.25% faster)


def test_denominator_object(parser):
    # Edge: denominator is a custom object
    class Y:
        def __str__(self):
            return "Y"

    toks = {"num": DummyNum("num"), "den": DummyDen(Y())}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.35μs -> 2.37μs (0.676% slower)


def test_missing_numerator_key(parser):
    # Edge: missing numerator key should raise KeyError
    toks = {"den": DummyDen(2)}
    with pytest.raises(KeyError):
        parser.dfrac(toks)  # 2.51μs -> 2.53μs (0.751% slower)


def test_missing_denominator_key(parser):
    # Edge: missing denominator key should raise KeyError
    toks = {"num": DummyNum(2)}
    with pytest.raises(KeyError):
        parser.dfrac(toks)  # 2.68μs -> 2.62μs (2.41% faster)


def test_numerator_has_shrink_called(parser):
    # Edge: shrink is called on numerator
    class ShrinkNum(DummyNum):
        def __init__(self, value):
            super().__init__(value)
            self.shrunk = False

        def shrink(self):
            self.shrunk = True

    num = ShrinkNum(7)
    den = DummyDen(8)
    toks = {"num": num, "den": den}
    parser.dfrac(toks)  # 2.40μs -> 2.34μs (2.43% faster)


def test_denominator_has_shrink_called(parser):
    # Edge: shrink is called on denominator
    class ShrinkDen(DummyDen):
        def __init__(self, value):
            super().__init__(value)
            self.shrunk = False

        def shrink(self):
            self.shrunk = True

    num = DummyNum(7)
    den = ShrinkDen(8)
    toks = {"num": num, "den": den}
    parser.dfrac(toks)  # 2.40μs -> 2.39μs (0.670% faster)


# 3. Large Scale Test Cases


def test_large_scale_long_string_numerator(parser):
    # Large: very long string numerator
    long_str = "x" * 1000
    toks = {"num": DummyNum(long_str), "den": DummyDen("y")}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.35μs -> 2.25μs (4.13% faster)


def test_large_scale_long_string_denominator(parser):
    # Large: very long string denominator
    long_str = "y" * 1000
    toks = {"num": DummyNum("x"), "den": DummyDen(long_str)}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.38μs -> 2.29μs (3.93% faster)


def test_large_scale_large_number_numerator(parser):
    # Large: very large number numerator
    large_num = 10**300
    toks = {"num": DummyNum(large_num), "den": DummyDen(1)}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.25μs -> 2.36μs (4.79% slower)


def test_large_scale_large_number_denominator(parser):
    # Large: very large number denominator
    large_den = 10**300
    toks = {"num": DummyNum(1), "den": DummyDen(large_den)}
    codeflash_output = parser.dfrac(toks)
    result = codeflash_output  # 2.36μs -> 2.33μs (1.59% faster)


def test_large_scale_many_calls(parser):
    # Large: call dfrac 1000 times with unique values
    for i in range(1, 1001):
        toks = {"num": DummyNum(i), "den": DummyDen(i + 1)}
        codeflash_output = parser.dfrac(toks)
        result = codeflash_output  # 582μs -> 548μs (6.19% faster)


def test_large_scale_various_types(parser):
    # Large: call dfrac with various types in a loop
    for i in range(100):
        if i % 4 == 0:
            num, den = DummyNum(i), DummyDen(i + 1)
        elif i % 4 == 1:
            num, den = DummyNum(str(i)), DummyDen(str(i + 1))
        elif i % 4 == 2:
            num, den = DummyNum(i + 0.5), DummyDen(i + 1.5)
        else:
            num, den = DummyNum(None), DummyDen(None)
        toks = {"num": num, "den": den}
        codeflash_output = parser.dfrac(toks)
        result = codeflash_output  # 62.2μs -> 59.0μs (5.40% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.